////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                                            //
//                                                         WNProject                                                          //
//                                                                                                                            //
//            This file is distributed under the BSD 2-Clause open source license. See License.txt for details.               //
//                                                                                                                            //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Types -----------------------------------------------------------------------------------------------------------------------
//      WN_VOID
//      WN_BYTE
//      WN_BOOL
//      WN_CHAR
//      WN_WCHAR
//      WN_INT8
//      WN_INT16
//      WN_INT32
//      WN_INT64
//      WN_UINT8
//      WN_UINT16
//      WN_UINT32
//      WN_UINT64
//      WN_FIXED8
//      WN_FIXED16
//      WN_FIXED32
//      WN_FIXED64
//      WN_FLOAT8
//      WN_FLOAT16
//      WN_FLOAT32
//      WN_FLOAT64
//      WN_POINTER
//      WN_SIZE_T
//      WN_ATOM_T

// Values ----------------------------------------------------------------------------------------------------------------------
//      WN_TRUE
//      WN_FALSE
//      WN_NULL
//      WN_FIXED8_MAX
//      WN_FIXED8_MIN
//      WN_FIXED16_MAX
//      WN_FIXED16_MIN
//      WN_FIXED32_MAX
//      WN_FIXED32_MIN
//      WN_FIXED64_MAX
//      WN_FIXED64_MIN
//      WN_FLOAT8_EPSILON
//      WN_FLOAT8_MAX
//      WN_FLOAT8_MIN
//      WN_FLOAT16_EPSILON
//      WN_FLOAT16_MAX
//      WN_FLOAT16_MIN
//      WN_FLOAT32_EPSILON
//      WN_FLOAT32_MAX
//      WN_FLOAT32_MIN
//      WN_FLOAT64_EPSILON
//      WN_FLOAT64_MAX
//      WN_FLOAT64_MIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef __WN_CORE_TYPES_H__
#define __WN_CORE_TYPES_H__

#include "WNCore/inc/WNPlatform.h"

#ifdef _WN_MSVC
    typedef unsigned __int8 WN_BYTE;

    typedef __int8 WN_INT8;
    typedef __int16 WN_INT16;
    typedef __int32 WN_INT32;
    typedef __int64 WN_INT64;

    typedef unsigned __int8 WN_UINT8;
    typedef unsigned __int16 WN_UINT16;
    typedef unsigned __int32 WN_UINT32;
    typedef unsigned __int64 WN_UINT64;

    #define __WN_HAS_WCHAR_CUSTOM

    typedef __wchar_t WN_WCHAR;

    #if defined _WN_X86 && defined _WN_64_BIT
        #define __WN_HAS_ATOM_T_CUSTOM

        typedef __int64 WN_ATOM_T;
    #endif

    #ifdef __WN_HAS_NULLPTR_CUSTOM
        #define WN_NULL __nullptr
    #endif
#elif defined _WN_GNUC
    #include <stdint.h>

    typedef uint8_t WN_BYTE;

    typedef int8_t WN_INT8;
    typedef int16_t WN_INT16;
    typedef int32_t WN_INT32;
    typedef int64_t WN_INT64;

    typedef uint8_t WN_UINT8;
    typedef uint16_t WN_UINT16;
    typedef uint32_t WN_UINT32;
    typedef uint64_t WN_UINT64;

    #ifdef __WN_HAS_NULLPTR_CUSTOM
        #define WN_NULL __null
    #endif
#endif

typedef void WN_VOID;

typedef char WN_CHAR;

typedef bool WN_BOOL;

typedef size_t WN_SIZE_T;

typedef WN_BYTE* WN_POINTER;

#define WN_TRUE true
#define WN_FALSE false

#include <float.h>

#define WN_FLOAT32_EPSILON FLT_EPSILON
#define WN_FLOAT32_MAX FLT_MAX
#define WN_FLOAT32_MIN FLT_MIN

#define WN_FLOAT64_EPSILON DBL_EPSILON
#define WN_FLOAT64_MAX DBL_MAX
#define WN_FLOAT64_MIN DBL_MIN

typedef float WN_FLOAT32;
typedef double WN_FLOAT64;

#ifndef __WN_HAS_WCHAR_CUSTOM
    typedef wchar_t WN_WCHAR;
#endif

#ifndef __WN_HAS_ATOM_T_CUSTOM
    #ifdef _WN_32_BIT
        typedef long int WN_ATOM_T;
    #elif defined _WN_64_BIT
        typedef long long WN_ATOM_T;
    #endif
#endif

#ifndef WN_NULL
    #if __WN_CPLUSPLUS >= 201103L || defined __WN_HAS_NULLPTR
        #define WN_NULL nullptr
    #else
        const
        class {
        public:
            template<class Type>
            operator Type * () const { return 0; }
            template<class Class, class Type>
            operator Type Class::* () const { return 0; }

        private:
            WN_VOID operator & () const;
        } __WNNullPtr = {};

        #define WN_NULL __WNNullPtr
    #endif
#endif

class __WNFloat16;
class __WNFixed8;
class __WNFixed16;
class __WNFixed32;
class __WNFixed64;

#define WN_FLOAT8_EPSILON
#define WN_FLOAT8_MAX
#define WN_FLOAT8_MIN

#define WN_FLOAT16_EPSILON 4.8875809e-4f
#define WN_FLOAT16_MAX 6.5504000e+4f
#define WN_FLOAT16_MIN 6.1035156e-5f

class __WNFloat8 {
public:
    WN_INLINE __WNFloat8() {}
    explicit WN_INLINE __WNFloat8(WN_INT8 _integer8);
    explicit WN_INLINE __WNFloat8(WN_INT16 _integer16);
    explicit WN_INLINE __WNFloat8(WN_INT32 _integer32);
    explicit WN_INLINE __WNFloat8(WN_INT64 _integer64);
    explicit WN_INLINE __WNFloat8(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFloat8(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFloat8(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFloat8(WN_UINT64 _integer64);
    explicit WN_INLINE __WNFloat8(const __WNFixed8& _fixed8);
    explicit WN_INLINE __WNFloat8(const __WNFixed16& _fixed16);
    explicit WN_INLINE __WNFloat8(const __WNFixed32& _fixed32);
    explicit WN_INLINE __WNFloat8(const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8(const __WNFloat8& _float8);
    WN_INLINE __WNFloat8(const __WNFloat16& _float16);
    WN_INLINE __WNFloat8(WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFloat8& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFloat8& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFloat8& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFloat8& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFloat8& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFloat8& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFloat8& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFloat8& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat8& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat8& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat8& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFloat8& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFloat8& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat8 operator + () const;
    WN_INLINE __WNFloat8 operator - () const;

    WN_INLINE __WNFloat8& operator ++ ();
    WN_INLINE __WNFloat8 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator -- ();
    WN_INLINE __WNFloat8 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat8& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFloat8& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFloat8& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFloat8& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFloat8& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFloat8& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFloat8& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFloat8& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat8& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat8& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat8& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFloat8& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFloat8& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat8& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFloat8& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFloat8& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFloat8& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat8& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat8& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat8& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat8& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat8& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat8& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat8& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat8& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat8& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat8& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFloat8& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFloat8& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFloat8& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat8& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat8& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat8& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat8& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat8& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat8& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat8& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat8& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat8& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat8& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFloat8& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFloat8& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFloat8& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFloat8& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat8& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat8& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat8& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat8& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat8& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat8& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat8& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat8& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat8& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat8& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat8& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat8 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat8 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat8 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat8 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat8 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat8 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat8 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat8 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat8 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat8 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat8 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat8 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat8 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat8 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat8 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat8 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat8 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat8 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat8 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat8 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat8 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat8 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat8 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat8 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat8 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat8 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat8 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat8 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat8 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat8 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat8 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat8 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat8 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat8 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat8 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat8 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat8 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat8 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat8 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat8 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat8 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat8 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat8 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat8 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

private:
    static WN_INLINE WN_INT8 F32ToF8(WN_FLOAT32 _float32);
    static WN_INLINE WN_FLOAT32 F8ToF32(WN_INT8 _float8);

public:
    WN_INT8 mBits; // stores 8 bit floating point http://en.wikipedia.org/wiki/Minifloat
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFloat8& _float8);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFloat8& _float8);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFloat8& _float8);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFloat8& _float8);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFloat8& _float8);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFloat8& _float8);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFloat8& _float8);

WN_INLINE __WNFloat8 operator + (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator + (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE __WNFloat8 operator - (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator - (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE __WNFloat8 operator * (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator * (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFloat8& _float8);

WN_INLINE __WNFloat8 operator / (WN_INT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_INT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_INT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_INT64 _integer64, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_UINT8 _integer8, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_UINT16 _integer16, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_UINT32 _integer32, const __WNFloat8& _float8);
WN_INLINE __WNFloat8 operator / (WN_UINT64 _integer64, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFloat8& _float8);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFloat8& _float8);

class __WNFloat16 {
public:
    WN_INLINE __WNFloat16() {}
    explicit WN_INLINE __WNFloat16(WN_INT8 _integer8);
    explicit WN_INLINE __WNFloat16(WN_INT16 _integer16);
    explicit WN_INLINE __WNFloat16(WN_INT32 _integer32);
    explicit WN_INLINE __WNFloat16(WN_INT64 _integer64);
    explicit WN_INLINE __WNFloat16(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFloat16(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFloat16(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFloat16(WN_UINT64 _integer64);
    explicit WN_INLINE __WNFloat16(const __WNFixed8& _fixed8);
    explicit WN_INLINE __WNFloat16(const __WNFixed16& _fixed16);
    explicit WN_INLINE __WNFloat16(const __WNFixed32& _fixed32);
    explicit WN_INLINE __WNFloat16(const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16(const __WNFloat8& _float8);
    WN_INLINE __WNFloat16(const __WNFloat16& _float16);
    WN_INLINE __WNFloat16(WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFloat16& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFloat16& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFloat16& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFloat16& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFloat16& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFloat16& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFloat16& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFloat16& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat16& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat16& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat16& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFloat16& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFloat16& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat16 operator + () const;
    WN_INLINE __WNFloat16 operator - () const;

    WN_INLINE __WNFloat16& operator ++ ();
    WN_INLINE __WNFloat16 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator -- ();
    WN_INLINE __WNFloat16 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat16& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFloat16& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFloat16& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFloat16& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFloat16& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFloat16& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFloat16& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFloat16& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat16& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat16& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat16& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFloat16& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFloat16& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat16& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFloat16& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFloat16& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFloat16& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat16& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat16& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat16& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat16& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat16& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat16& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat16& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat16& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat16& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat16& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFloat16& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFloat16& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFloat16& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat16& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat16& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat16& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat16& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat16& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat16& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat16& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat16& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat16& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat16& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFloat16& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFloat16& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFloat16& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFloat16& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFloat16& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFloat16& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFloat16& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFloat16& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFloat16& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFloat16& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFloat16& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFloat16& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFloat16& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFloat16& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFloat16& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFloat16 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat16 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat16 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat16 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat16 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat16 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat16 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat16 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat16 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat16 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat16 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat16 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat16 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat16 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat16 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat16 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat16 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat16 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat16 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat16 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat16 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat16 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat16 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat16 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat16 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat16 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat16 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat16 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat16 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat16 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat16 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat16 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat16 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFloat16 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFloat16 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFloat16 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFloat16 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFloat16 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFloat16 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFloat16 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFloat16 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFloat16 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFloat16 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFloat16 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

private:
    static WN_INLINE WN_INT16 F32ToF16(WN_FLOAT32 _float32);
    static WN_INLINE WN_FLOAT32 F16ToF32(WN_INT16 _float16);

public:
    WN_INT16 mBits; // stores 16 bit floating point http://en.wikipedia.org/wiki/Half-precision_floating-point_format
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFloat16& _float16);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFloat16& _float16);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFloat16& _float16);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFloat16& _float16);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFloat16& _float16);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFloat16& _float16);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFloat16& _float16);

WN_INLINE __WNFloat16 operator + (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator + (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE __WNFloat16 operator - (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator - (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE __WNFloat16 operator * (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator * (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFloat16& _float16);

WN_INLINE __WNFloat16 operator / (WN_INT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_INT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_INT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_INT64 _integer64, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_UINT8 _integer8, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_UINT16 _integer16, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_UINT32 _integer32, const __WNFloat16& _float16);
WN_INLINE __WNFloat16 operator / (WN_UINT64 _integer64, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFloat16& _float16);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFloat16& _float16);

typedef __WNFloat8 WN_FLOAT8;
typedef __WNFloat16 WN_FLOAT16;

#define WN_FIXED8_BITS 4
#define WN_FIXED8_MAX 7.9375
#define WN_FIXED8_MIN -8.0

#define WN_FIXED16_BITS 8
#define WN_FIXED16_MAX 127.99609375
#define WN_FIXED16_MIN -128.0

#define WN_FIXED32_BITS 16
#define WN_FIXED32_MAX 32767.9999847412109375
#define WN_FIXED32_MIN -32768.0

#define WN_FIXED64_BITS 32
#define WN_FIXED64_MAX 2147483647.9999999997671693563461
#define WN_FIXED64_MIN -2147483648.0

class __WNFixed8 {
public:
    WN_INLINE __WNFixed8() {}
    explicit WN_INLINE __WNFixed8(WN_INT8 _integer8);
    explicit WN_INLINE __WNFixed8(WN_INT16 _integer16);
    explicit WN_INLINE __WNFixed8(WN_INT32 _integer32);
    explicit WN_INLINE __WNFixed8(WN_INT64 _integer64);
    explicit WN_INLINE __WNFixed8(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFixed8(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFixed8(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFixed8(WN_UINT64 _integer64);
    WN_INLINE __WNFixed8(const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8(const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8(const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8(const __WNFixed64& _fixed64);
    explicit WN_INLINE __WNFixed8(const __WNFloat8& _float8);
    explicit WN_INLINE __WNFixed8(const __WNFloat16& _float16);
    explicit WN_INLINE __WNFixed8(WN_FLOAT32 _float32);
    explicit WN_INLINE __WNFixed8(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFixed8& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFixed8& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFixed8& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFixed8& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFixed8& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFixed8& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFixed8& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFixed8& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed8& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFixed8& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFixed8& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed8& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed8 operator + () const;
    WN_INLINE __WNFixed8 operator - () const;

    WN_INLINE __WNFixed8& operator ++ ();
    WN_INLINE __WNFixed8 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator -- ();
    WN_INLINE __WNFixed8 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed8& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFixed8& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFixed8& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFixed8& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFixed8& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFixed8& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFixed8& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFixed8& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed8& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFixed8& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFixed8& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed8& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed8& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFixed8& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFixed8& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFixed8& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed8& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed8& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed8& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed8& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed8& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed8& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed8& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed8& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed8& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFixed8& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFixed8& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFixed8& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed8& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed8& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed8& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed8& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed8& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed8& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed8& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed8& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed8& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFixed8& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFixed8& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFixed8& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFixed8& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed8& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed8& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed8& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed8& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed8& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed8& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed8& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed8& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed8& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed8& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed8& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed8 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed8 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed8 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed8 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed8 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed8 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed8 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed8 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed8 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed8 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed8 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed8 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed8 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed8 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed8 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed8 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed8 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed8 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed8 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed8 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed8 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed8 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed8 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed8 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed8 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed8 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed8 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed8 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed8 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed8 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed8 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed8 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed8 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed8 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed8 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed8 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

public:
    WN_INT8 mBits; // stores 8 bit fixed point number in form 1:3:4
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFixed8& _fixed8);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFixed8& _fixed8);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFixed8& _fixed8);

WN_INLINE __WNFixed8 operator + (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator + (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE __WNFixed8 operator - (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator - (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE __WNFixed8 operator * (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator * (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

WN_INLINE __WNFixed8 operator / (WN_INT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_INT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_INT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_INT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_UINT8 _integer8, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_UINT16 _integer16, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_UINT32 _integer32, const __WNFixed8& _fixed8);
WN_INLINE __WNFixed8 operator / (WN_UINT64 _integer64, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFixed8& _fixed8);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFixed8& _fixed8);

class __WNFixed16 {
public:
    WN_INLINE __WNFixed16() {}
    explicit WN_INLINE __WNFixed16(WN_INT8 _integer8);
    explicit WN_INLINE __WNFixed16(WN_INT16 _integer16);
    explicit WN_INLINE __WNFixed16(WN_INT32 _integer32);
    explicit WN_INLINE __WNFixed16(WN_INT64 _integer64);
    explicit WN_INLINE __WNFixed16(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFixed16(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFixed16(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFixed16(WN_UINT64 _integer64);
    WN_INLINE __WNFixed16(const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16(const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16(const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16(const __WNFixed64& _fixed64);
    explicit WN_INLINE __WNFixed16(const __WNFloat8& _float8);
    explicit WN_INLINE __WNFixed16(const __WNFloat16& _float16);
    explicit WN_INLINE __WNFixed16(WN_FLOAT32 _float32);
    explicit WN_INLINE __WNFixed16(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFixed16& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFixed16& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFixed16& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFixed16& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFixed16& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFixed16& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFixed16& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFixed16& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed16& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFixed16& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFixed16& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed16& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed16 operator + () const;
    WN_INLINE __WNFixed16 operator - () const;

    WN_INLINE __WNFixed16& operator ++ ();
    WN_INLINE __WNFixed16 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator -- ();
    WN_INLINE __WNFixed16 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed16& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFixed16& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFixed16& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFixed16& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFixed16& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFixed16& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFixed16& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFixed16& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed16& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFixed16& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFixed16& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed16& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed16& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFixed16& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFixed16& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFixed16& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed16& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed16& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed16& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed16& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed16& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed16& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed16& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed16& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed16& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFixed16& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFixed16& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFixed16& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed16& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed16& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed16& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed16& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed16& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed16& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed16& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed16& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed16& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFixed16& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFixed16& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFixed16& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFixed16& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed16& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed16& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed16& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed16& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed16& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed16& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed16& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed16& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed16& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed16& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed16& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed16 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed16 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed16 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed16 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed16 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed16 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed16 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed16 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed16 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed16 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed16 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed16 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed16 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed16 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed16 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed16 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed16 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed16 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed16 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed16 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed16 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed16 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed16 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed16 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed16 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed16 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed16 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed16 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed16 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed16 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed16 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed16 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed16 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed16 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed16 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed16 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed16 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

public:
    WN_INT16 mBits; // stores 16 bit fixed point number in form 1:7:8
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFixed16& _fixed16);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFixed16& _fixed16);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFixed16& _fixed16);

WN_INLINE __WNFixed16 operator + (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator + (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE __WNFixed16 operator - (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator - (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE __WNFixed16 operator * (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator * (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

WN_INLINE __WNFixed16 operator / (WN_INT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_INT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_INT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_INT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_UINT8 _integer8, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_UINT16 _integer16, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_UINT32 _integer32, const __WNFixed16& _fixed16);
WN_INLINE __WNFixed16 operator / (WN_UINT64 _integer64, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFixed16& _fixed16);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFixed16& _fixed16);

class __WNFixed32 {
public:
    WN_INLINE __WNFixed32() {}
    explicit WN_INLINE __WNFixed32(WN_INT8 _integer8);
    explicit WN_INLINE __WNFixed32(WN_INT16 _integer16);
    explicit WN_INLINE __WNFixed32(WN_INT32 _integer32);
    explicit WN_INLINE __WNFixed32(WN_INT64 _integer64);
    explicit WN_INLINE __WNFixed32(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFixed32(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFixed32(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFixed32(WN_UINT64 _integer64);
    WN_INLINE __WNFixed32(const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32(const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32(const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32(const __WNFixed64& _fixed64);
    explicit WN_INLINE __WNFixed32(const __WNFloat8& _float8);
    explicit WN_INLINE __WNFixed32(const __WNFloat16& _float16);
    explicit WN_INLINE __WNFixed32(WN_FLOAT32 _float32);
    explicit WN_INLINE __WNFixed32(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFixed32& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFixed32& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFixed32& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFixed32& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFixed32& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFixed32& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFixed32& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFixed32& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed32& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFixed32& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFixed32& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed32& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed32 operator + () const;
    WN_INLINE __WNFixed32 operator - () const;

    WN_INLINE __WNFixed32& operator ++ ();
    WN_INLINE __WNFixed32 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator -- ();
    WN_INLINE __WNFixed32 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed32& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFixed32& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFixed32& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFixed32& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFixed32& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFixed32& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFixed32& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFixed32& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed32& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFixed32& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFixed32& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed32& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed32& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFixed32& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFixed32& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFixed32& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed32& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed32& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed32& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed32& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed32& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed32& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed32& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed32& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed32& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFixed32& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFixed32& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFixed32& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed32& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed32& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed32& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed32& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed32& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed32& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed32& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed32& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed32& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFixed32& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFixed32& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFixed32& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFixed32& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed32& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed32& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed32& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed32& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed32& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed32& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed32& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed32& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed32& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed32& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed32& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed32 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed32 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed32 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed32 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed32 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed32 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed32 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed32 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed32 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed32 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed32 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed32 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed32 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed32 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed32 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed32 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed32 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed32 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed32 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed32 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed32 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed32 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed32 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed32 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed32 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed32 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed32 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed32 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed32 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed32 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed32 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed32 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed32 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed32 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed32 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed32 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed32 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed32 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed32 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed32 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed32 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

public:
    WN_INT32 mBits; // stores 32 bit fixed point number in form 1:15:16
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFixed32& _fixed32);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFixed32& _fixed32);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFixed32& _fixed32);

WN_INLINE __WNFixed32 operator + (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator + (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE __WNFixed32 operator - (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator - (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE __WNFixed32 operator * (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator * (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

WN_INLINE __WNFixed32 operator / (WN_INT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_INT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_INT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_INT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_UINT8 _integer8, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_UINT16 _integer16, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_UINT32 _integer32, const __WNFixed32& _fixed32);
WN_INLINE __WNFixed32 operator / (WN_UINT64 _integer64, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFixed32& _fixed32);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFixed32& _fixed32);

class __WNFixed64 {
public:
    WN_INLINE __WNFixed64() {}
    explicit WN_INLINE __WNFixed64(WN_INT8 _integer8);
    explicit WN_INLINE __WNFixed64(WN_INT16 _integer16);
    explicit WN_INLINE __WNFixed64(WN_INT32 _integer32);
    explicit WN_INLINE __WNFixed64(WN_INT64 _integer64);
    explicit WN_INLINE __WNFixed64(WN_UINT8 _integer8);
    explicit WN_INLINE __WNFixed64(WN_UINT16 _integer16);
    explicit WN_INLINE __WNFixed64(WN_UINT32 _integer32);
    explicit WN_INLINE __WNFixed64(WN_UINT64 _integer64);
    WN_INLINE __WNFixed64(const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64(const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64(const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64(const __WNFixed64& _fixed64);
    explicit WN_INLINE __WNFixed64(const __WNFloat8& _float8);
    explicit WN_INLINE __WNFixed64(const __WNFloat16& _float16);
    explicit WN_INLINE __WNFixed64(WN_FLOAT32 _float32);
    explicit WN_INLINE __WNFixed64(WN_FLOAT64 _float64);

    WN_INLINE operator WN_INT8 () const;
    WN_INLINE operator WN_INT16 () const;
    WN_INLINE operator WN_INT32 () const;
    WN_INLINE operator WN_INT64 () const;
    WN_INLINE operator WN_UINT8 () const;
    WN_INLINE operator WN_UINT16 () const;
    WN_INLINE operator WN_UINT32 () const;
    WN_INLINE operator WN_UINT64 () const;
    WN_INLINE operator WN_FLOAT32 () const;
    WN_INLINE operator WN_FLOAT64 () const;

    WN_INLINE __WNFixed64& operator = (WN_INT8 _integer8);
    WN_INLINE __WNFixed64& operator = (WN_INT16 _integer16);
    WN_INLINE __WNFixed64& operator = (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator = (WN_INT64 _integer64);
    WN_INLINE __WNFixed64& operator = (WN_UINT8 _integer8);
    WN_INLINE __WNFixed64& operator = (WN_UINT16 _integer16);
    WN_INLINE __WNFixed64& operator = (WN_UINT32 _integer32);
    WN_INLINE __WNFixed64& operator = (WN_UINT64 _integer64);
    WN_INLINE __WNFixed64& operator = (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64& operator = (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64& operator = (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64& operator = (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed64& operator = (const __WNFloat8& _float8);
    WN_INLINE __WNFixed64& operator = (const __WNFloat16& _float16);
    WN_INLINE __WNFixed64& operator = (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed64& operator = (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed64 operator + () const;
    WN_INLINE __WNFixed64 operator - () const;

    WN_INLINE __WNFixed64& operator ++ ();
    WN_INLINE __WNFixed64 operator ++ (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator -- ();
    WN_INLINE __WNFixed64 operator -- (WN_INT32 _integer32);

    WN_INLINE WN_BOOL operator ! () const;

    WN_INLINE WN_BOOL operator && (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator && (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator && (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator || (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator || (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator || (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator == (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator == (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator == (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator != (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator != (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator != (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator <= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator <= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator >= (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator >= (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator < (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator < (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator < (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64) const;

    WN_INLINE WN_BOOL operator > (WN_INT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_INT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_INT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_INT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8) const;
    WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16) const;
    WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32) const;
    WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed8& _fixed8) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed16& _fixed16) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed32& _fixed32) const;
    WN_INLINE WN_BOOL operator > (const __WNFixed64& _fixed64) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat8& _float8) const;
    WN_INLINE WN_BOOL operator > (const __WNFloat16& _float16) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32) const;
    WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed64& operator += (WN_INT8 _integer8);
    WN_INLINE __WNFixed64& operator += (WN_INT16 _integer16);
    WN_INLINE __WNFixed64& operator += (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator += (WN_INT64 _integer64);
    WN_INLINE __WNFixed64& operator += (WN_UINT8 _integer8);
    WN_INLINE __WNFixed64& operator += (WN_UINT16 _integer16);
    WN_INLINE __WNFixed64& operator += (WN_UINT32 _integer32);
    WN_INLINE __WNFixed64& operator += (WN_UINT64 _integer64);
    WN_INLINE __WNFixed64& operator += (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64& operator += (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64& operator += (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64& operator += (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed64& operator += (const __WNFloat8& _float8);
    WN_INLINE __WNFixed64& operator += (const __WNFloat16& _float16);
    WN_INLINE __WNFixed64& operator += (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed64& operator += (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed64& operator -= (WN_INT8 _integer8);
    WN_INLINE __WNFixed64& operator -= (WN_INT16 _integer16);
    WN_INLINE __WNFixed64& operator -= (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator -= (WN_INT64 _integer64);
    WN_INLINE __WNFixed64& operator -= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed64& operator -= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed64& operator -= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed64& operator -= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed64& operator -= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64& operator -= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64& operator -= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64& operator -= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed64& operator -= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed64& operator -= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed64& operator -= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed64& operator -= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed64& operator *= (WN_INT8 _integer8);
    WN_INLINE __WNFixed64& operator *= (WN_INT16 _integer16);
    WN_INLINE __WNFixed64& operator *= (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator *= (WN_INT64 _integer64);
    WN_INLINE __WNFixed64& operator *= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed64& operator *= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed64& operator *= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed64& operator *= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed64& operator *= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64& operator *= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64& operator *= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64& operator *= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed64& operator *= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed64& operator *= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed64& operator *= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed64& operator *= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed64& operator /= (WN_INT8 _integer8);
    WN_INLINE __WNFixed64& operator /= (WN_INT16 _integer16);
    WN_INLINE __WNFixed64& operator /= (WN_INT32 _integer32);
    WN_INLINE __WNFixed64& operator /= (WN_INT64 _integer64);
    WN_INLINE __WNFixed64& operator /= (WN_UINT8 _integer8);
    WN_INLINE __WNFixed64& operator /= (WN_UINT16 _integer16);
    WN_INLINE __WNFixed64& operator /= (WN_UINT32 _integer32);
    WN_INLINE __WNFixed64& operator /= (WN_UINT64 _integer64);
    WN_INLINE __WNFixed64& operator /= (const __WNFixed8& _fixed8);
    WN_INLINE __WNFixed64& operator /= (const __WNFixed16& _fixed16);
    WN_INLINE __WNFixed64& operator /= (const __WNFixed32& _fixed32);
    WN_INLINE __WNFixed64& operator /= (const __WNFixed64& _fixed64);
    WN_INLINE __WNFixed64& operator /= (const __WNFloat8& _float8);
    WN_INLINE __WNFixed64& operator /= (const __WNFloat16& _float16);
    WN_INLINE __WNFixed64& operator /= (WN_FLOAT32 _float32);
    WN_INLINE __WNFixed64& operator /= (WN_FLOAT64 _float64);

    WN_INLINE __WNFixed64 operator + (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed64 operator + (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed64 operator + (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed64 operator + (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed64 operator + (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed64 operator + (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed64 operator + (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed64 operator + (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator + (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator + (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator + (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed64 operator - (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed64 operator - (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed64 operator - (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed64 operator - (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed64 operator - (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed64 operator - (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed64 operator - (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed64 operator - (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator - (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator - (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator - (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed64 operator * (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed64 operator * (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed64 operator * (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed64 operator * (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed64 operator * (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed64 operator * (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed64 operator * (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed64 operator * (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator * (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator * (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator * (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64) const;

    WN_INLINE __WNFixed64 operator / (WN_INT8 _integer8) const;
    WN_INLINE __WNFixed64 operator / (WN_INT16 _integer16) const;
    WN_INLINE __WNFixed64 operator / (WN_INT32 _integer32) const;
    WN_INLINE __WNFixed64 operator / (WN_INT64 _integer64) const;
    WN_INLINE __WNFixed64 operator / (WN_UINT8 _integer8) const;
    WN_INLINE __WNFixed64 operator / (WN_UINT16 _integer16) const;
    WN_INLINE __WNFixed64 operator / (WN_UINT32 _integer32) const;
    WN_INLINE __WNFixed64 operator / (WN_UINT64 _integer64) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed8& _fixed8) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed16& _fixed16) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed32& _fixed32) const;
    WN_INLINE __WNFixed64 operator / (const __WNFixed64& _fixed64) const;
    WN_INLINE __WNFloat8 operator / (const __WNFloat8& _float8) const;
    WN_INLINE __WNFloat16 operator / (const __WNFloat16& _float16) const;
    WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32) const;
    WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64) const;

public:
    WN_INT64 mBits; // stores 64 bit fixed point number in form 1:31:32
};

WN_INLINE WN_BOOL operator && (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator && (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator || (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator || (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator == (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator == (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator != (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator != (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator <= (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator <= (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator >= (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator >= (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator < (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator < (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_BOOL operator > (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_BOOL operator > (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_INT8& operator += (WN_INT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_INT16& operator += (WN_INT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_INT32& operator += (WN_INT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_INT64& operator += (WN_INT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT8& operator += (WN_UINT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT16& operator += (WN_UINT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT32& operator += (WN_UINT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT64& operator += (WN_UINT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32& operator += (WN_FLOAT32& _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64& operator += (WN_FLOAT64& _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_INT8& operator -= (WN_INT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_INT16& operator -= (WN_INT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_INT32& operator -= (WN_INT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_INT64& operator -= (WN_INT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT8& operator -= (WN_UINT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT16& operator -= (WN_UINT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT32& operator -= (WN_UINT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT64& operator -= (WN_UINT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32& operator -= (WN_FLOAT32& _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64& operator -= (WN_FLOAT64& _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_INT8& operator *= (WN_INT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_INT16& operator *= (WN_INT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_INT32& operator *= (WN_INT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_INT64& operator *= (WN_INT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT8& operator *= (WN_UINT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT16& operator *= (WN_UINT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT32& operator *= (WN_UINT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT64& operator *= (WN_UINT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32& operator *= (WN_FLOAT32& _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64& operator *= (WN_FLOAT64& _float64, const __WNFixed64& _fixed64);

WN_INLINE WN_INT8& operator /= (WN_INT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_INT16& operator /= (WN_INT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_INT32& operator /= (WN_INT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_INT64& operator /= (WN_INT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT8& operator /= (WN_UINT8& _integer8, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT16& operator /= (WN_UINT16& _integer16, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT32& operator /= (WN_UINT32& _integer32, const __WNFixed64& _fixed64);
WN_INLINE WN_UINT64& operator /= (WN_UINT64& _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32& operator /= (WN_FLOAT32& _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64& operator /= (WN_FLOAT64& _float64, const __WNFixed64& _fixed64);

WN_INLINE __WNFixed64 operator + (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator + (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32 operator + (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64 operator + (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE __WNFixed64 operator - (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator - (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32 operator - (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64 operator - (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE __WNFixed64 operator * (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator * (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32 operator * (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64 operator * (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

WN_INLINE __WNFixed64 operator / (WN_INT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_INT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_INT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_INT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_UINT8 _integer8, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_UINT16 _integer16, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_UINT32 _integer32, const __WNFixed64& _fixed64);
WN_INLINE __WNFixed64 operator / (WN_UINT64 _integer64, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT32 operator / (WN_FLOAT32 _float32, const __WNFixed64& _fixed64);
WN_INLINE WN_FLOAT64 operator / (WN_FLOAT64 _float64, const __WNFixed64& _fixed64);

typedef __WNFixed8 WN_FIXED8;
typedef __WNFixed16 WN_FIXED16;
typedef __WNFixed32 WN_FIXED32;
typedef __WNFixed64 WN_FIXED64;

#include "WNCore/inc/WNTypes.inl"

#endif // __WN_CORE_TYPES_H__